Compiling ER Specifications into Declarative Programs

This paper proposes an environment to support high-level database programming in a declarative programming language. In order to ensure safe database updates, all access and update operations related to the database are generated from high-level descriptions in the entity- relationship (ER) model. We propose a representation of ER diagrams in the declarative language Curry so that they can be constructed by various tools and then translated into this representation. Furthermore, we have implemented a compiler from this representation into a Curry program that provides access and update operations based on a high-level API for database programming.Comment: Paper presented at the 17th Workshop on Logic-based Methods in Programming Environments (WLPE2007

Implementing Functional Logic Programs by Translation into Purely Functional Programs

This work examines a transformation scheme from functional logic programs to purely functional programs both formally and experimentally

Delta Debugging Type Errors with a Blackbox Compiler

Debugging type errors is a necessary process that programmers, both novices and experts alike, face when using statically typed functional programming languages. All compilers often report the location of a type error inaccurately. This problem has been a subject of research for over thirty years. We present a new method for locating type errors: We apply the Isolating Delta Debugging algorithm coupled with a blackbox compiler. We evaluate our implementation for Haskell by comparing it with the output of the Glasgow Haskell Compiler; overall we obtain positive results in favour of our method of type error debugging

Computing with subspaces

We propose a new definition and use of a primitivegetAllValues, for computing all the values of a non-deterministic expression in a functional logic program. Our proposal restricts the validity of the argument of getAllValues. This restriction ensures that essential language features like the call-time choice semantics, the independence of the order of evaluation, and the referential transparency of the language are preserved when getAllValues is executed. Up to now, conflicts between these language features and primitives like getAllValues have been seen as one of the main problems for employing such primitives in functional logic languages

Mode Analysis of Functional Logic Programs

Abstract. Information about the nondeterminism behavior of a functional logic program is important for various reasons. For instance, a nondeterministic choice in I/O operations results in a run-time error. Thus, it is desirable to ensure at compile time that a given program is not going to crash in this way. Furthermore, knowledge about nondeterminism can be exploited to optimize programs. In particular, if functional logic programs are compiled to target languages without builtin support for nondeterministic computations, the transformation can be much simpler if it is known that the source program is deterministic. In this paper we present a nondeterminism analysis of functional logic programs in form of a type/effect system. We present a type inferencer to approximate the nondeterminism behavior via nonstandard types and show its correctness w.r.t. the operational semantics of functional logic programs. The type inference is based on a new compact representation of sets of types and effects.

A Relation Algebraic Semantics for a Lazy Functional Logic Language

Abstract. We propose a special relation algebraic model as semantics for lazy functional logic languages. The resulting semantics provides several interesting advantages over former approaches for this class of languages. For once, the equational reasoning supported by an algebraic approach implies a great increase in the economy and readability of proofs. Second, the richly developed field of relation algebra provides a pool of theorems and insights that can now be utilized in reasoning about functional logic programs. A further advantage is the strong and simple correspondence between functional logic programs and the semantics developed here. This correspondence enables us to go both ways, i.e. from program to semantics and back. The latter direction is essential for using relation algebraic transformations to optimize functional logic code. Last but not least, the development of the relation algebraic formalization gave us valuable insights, especially with respect to the desired properties of function inversion.